home *** CD-ROM | disk | FTP | other *** search
/ Enter 2006 September / Enter 09 2006.iso / Internet / SpamExperts Home 1.1 / SpamExperts Home.exe / lib / spamexperts.modules / encodings / punycode.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-07-14  |  6.7 KB  |  246 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. ''' Codec for the Punicode encoding, as specified in RFC 3492
  5.  
  6. Written by Martin v. L\xf6wis.
  7. '''
  8. import codecs
  9.  
  10. def segregate(str):
  11.     '''3.1 Basic code point segregation'''
  12.     base = []
  13.     extended = { }
  14.     for c in str:
  15.         if ord(c) < 128:
  16.             base.append(c)
  17.             continue
  18.         extended[c] = 1
  19.     
  20.     extended = extended.keys()
  21.     extended.sort()
  22.     return (''.join(base).encode('ascii'), extended)
  23.  
  24.  
  25. def selective_len(str, max):
  26.     '''Return the length of str, considering only characters below max.'''
  27.     res = 0
  28.     for c in str:
  29.         if ord(c) < max:
  30.             res += 1
  31.             continue
  32.     
  33.     return res
  34.  
  35.  
  36. def selective_find(str, char, index, pos):
  37.     '''Return a pair (index, pos), indicating the next occurrence of
  38.     char in str. index is the position of the character considering
  39.     only ordinals up to and including char, and pos is the position in
  40.     the full string. index/pos is the starting position in the full
  41.     string.'''
  42.     l = len(str)
  43.     while None:
  44.         pos += 1
  45.         if pos == l:
  46.             return (-1, -1)
  47.         
  48.         c = str[pos]
  49.         if c == char:
  50.             return (index + 1, pos)
  51.             continue
  52.         if c < char:
  53.             index += 1
  54.             continue
  55.  
  56.  
  57. def insertion_unsort(str, extended):
  58.     '''3.2 Insertion unsort coding'''
  59.     oldchar = 128
  60.     result = []
  61.     oldindex = -1
  62.     for c in extended:
  63.         index = pos = -1
  64.         char = ord(c)
  65.         curlen = selective_len(str, char)
  66.         delta = (curlen + 1) * (char - oldchar)
  67.         while None:
  68.             (index, pos) = selective_find(str, c, index, pos)
  69.             if index == -1:
  70.                 break
  71.             
  72.             delta += index - oldindex
  73.             oldindex = index
  74.             delta = 0
  75.         oldchar = char
  76.     
  77.     return result
  78.  
  79.  
  80. def T(j, bias):
  81.     res = 36 * (j + 1) - bias
  82.     if res < 1:
  83.         return 1
  84.     
  85.     if res > 26:
  86.         return 26
  87.     
  88.     return res
  89.  
  90. digits = 'abcdefghijklmnopqrstuvwxyz0123456789'
  91.  
  92. def generate_generalized_integer(N, bias):
  93.     '''3.3 Generalized variable-length integers'''
  94.     result = []
  95.     j = 0
  96.     while None:
  97.         t = T(j, bias)
  98.         if N < t:
  99.             result.append(digits[N])
  100.             return result
  101.         
  102.         N = (N - t) // (36 - t)
  103.         j += 1
  104.  
  105.  
  106. def adapt(delta, first, numchars):
  107.     if first:
  108.         delta //= 700
  109.     else:
  110.         delta //= 2
  111.     delta += delta // numchars
  112.     divisions = 0
  113.     while delta > 455:
  114.         delta = delta // 35
  115.         divisions += 36
  116.     bias = divisions + 36 * delta // (delta + 38)
  117.     return bias
  118.  
  119.  
  120. def generate_integers(baselen, deltas):
  121.     '''3.4 Bias adaptation'''
  122.     result = []
  123.     bias = 72
  124.     for points, delta in enumerate(deltas):
  125.         s = generate_generalized_integer(delta, bias)
  126.         result.extend(s)
  127.         bias = adapt(delta, points == 0, baselen + points + 1)
  128.     
  129.     return ''.join(result)
  130.  
  131.  
  132. def punycode_encode(text):
  133.     (base, extended) = segregate(text)
  134.     base = base.encode('ascii')
  135.     deltas = insertion_unsort(text, extended)
  136.     extended = generate_integers(len(base), deltas)
  137.     if base:
  138.         return base + '-' + extended
  139.     
  140.     return extended
  141.  
  142.  
  143. def decode_generalized_number(extended, extpos, bias, errors):
  144.     '''3.3 Generalized variable-length integers'''
  145.     result = 0
  146.     w = 1
  147.     j = 0
  148.     while None:
  149.         
  150.         try:
  151.             char = ord(extended[extpos])
  152.         except IndexError:
  153.             if errors == 'strict':
  154.                 raise UnicodeError, 'incomplete punicode string'
  155.             
  156.             return (extpos + 1, None)
  157.  
  158.         extpos += 1
  159.         if char <= char:
  160.             pass
  161.         elif char <= 90:
  162.             digit = char - 65
  163.         elif char <= char:
  164.             pass
  165.         elif char <= 57:
  166.             digit = char - 22
  167.         elif errors == 'strict':
  168.             raise UnicodeError("Invalid extended code point '%s'" % extended[extpos])
  169.         else:
  170.             return (extpos, None)
  171.         t = T(j, bias)
  172.         result += digit * w
  173.         if digit < t:
  174.             return (extpos, result)
  175.         
  176.         w = w * (36 - t)
  177.         j += 1
  178.  
  179.  
  180. def insertion_sort(base, extended, errors):
  181.     '''3.2 Insertion unsort coding'''
  182.     char = 128
  183.     pos = -1
  184.     bias = 72
  185.     extpos = 0
  186.     while extpos < len(extended):
  187.         (newpos, delta) = decode_generalized_number(extended, extpos, bias, errors)
  188.         if delta is None:
  189.             return base
  190.         
  191.         pos += delta + 1
  192.         char += pos // (len(base) + 1)
  193.         if char > 1114111:
  194.             if errors == 'strict':
  195.                 raise UnicodeError, 'Invalid character U+%x' % char
  196.             
  197.             char = ord('?')
  198.         
  199.         pos = pos % (len(base) + 1)
  200.         base = base[:pos] + unichr(char) + base[pos:]
  201.         bias = adapt(delta, extpos == 0, len(base))
  202.         extpos = newpos
  203.     return base
  204.  
  205.  
  206. def punycode_decode(text, errors):
  207.     pos = text.rfind('-')
  208.     if pos == -1:
  209.         base = ''
  210.         extended = text
  211.     else:
  212.         base = text[:pos]
  213.         extended = text[pos + 1:]
  214.     base = unicode(base, 'ascii', errors)
  215.     extended = extended.upper()
  216.     return insertion_sort(base, extended, errors)
  217.  
  218.  
  219. class Codec(codecs.Codec):
  220.     
  221.     def encode(self, input, errors = 'strict'):
  222.         res = punycode_encode(input)
  223.         return (res, len(input))
  224.  
  225.     
  226.     def decode(self, input, errors = 'strict'):
  227.         if errors not in ('strict', 'replace', 'ignore'):
  228.             raise UnicodeError, 'Unsupported error handling ' + errors
  229.         
  230.         res = punycode_decode(input, errors)
  231.         return (res, len(input))
  232.  
  233.  
  234.  
  235. class StreamWriter(Codec, codecs.StreamWriter):
  236.     pass
  237.  
  238.  
  239. class StreamReader(Codec, codecs.StreamReader):
  240.     pass
  241.  
  242.  
  243. def getregentry():
  244.     return (Codec().encode, Codec().decode, StreamReader, StreamWriter)
  245.  
  246.